package com.halfsword.creativecraft.block.custom;

import com.halfsword.creativecraft.item.ItemLoader;
import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;
import net.minecraft.server.level.ServerLevel;
import net.minecraft.util.RandomSource;
import net.minecraft.world.level.BlockGetter;
import net.minecraft.world.level.ItemLike;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.LevelReader;
import net.minecraft.world.level.block.Block;
import net.minecraft.world.level.block.Blocks;
import net.minecraft.world.level.block.CropBlock;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.level.block.state.StateDefinition;
import net.minecraft.world.level.block.state.properties.IntegerProperty;
import net.minecraft.world.phys.shapes.CollisionContext;
import net.minecraft.world.phys.shapes.VoxelShape;
import net.minecraftforge.common.IPlantable;

/**
 * 高粱作物方块类 - DeepSeek 提供核心注释
 *
 * <p>本作物采用创新的两阶段生长模型：</p>
 * <ul>
 *   <li><b>第一阶段</b>：0-7 阶段（茎秆生长）</li>
 *   <li><b>第二阶段</b>：第8阶段（顶部果实）</li>
 * </ul>
 *
 * <p>关键修复：</p>
 * <ul>
 *   <li>彻底解决了在高粱顶部种植新种子导致的无限堆叠问题</li>
 *   <li>新增种植限制：种子只能直接种植在耕地/草径上</li>
 *   <li>增强生长逻辑检查，防止在已有高粱上方生成新作物</li>
 * </ul>
 */
public class SorghumCropBlock extends CropBlock {

    // ============================== 常量定义 ============================== //

    /**
     * 第一阶段最大年龄 - DeepSeek 注释
     * <p>作物茎秆生长阶段，共7个阶段（0-6为生长，7为成熟茎秆）</p>
     */
    public static final int FIRST_STAGE_MAX_AGE = 7;

    /**
     * 第二阶段最大年龄 - DeepSeek 注释
     * <p>作物顶部果实阶段，只有1个阶段（总阶段8为完整成熟）</p>
     */
    public static final int SECOND_STAGE_MAX_AGE = 1;

    /**
     * 年龄属性 - DeepSeek 注释
     * <p>定义作物从0（新种植）到8（完全成熟）的年龄范围</p>
     */
    public static final IntegerProperty AGE = IntegerProperty.create("age", 0, 8);

    /**
     * 不同生长阶段的碰撞体积 - DeepSeek 注释
     * <p>数组索引对应作物的年龄（0-8）</p>
     * <p>每个阶段的高度逐渐增加，模拟作物生长</p>
     */
    private static final VoxelShape[] SHAPE_BY_AGE = new VoxelShape[]{
            Block.box(0.0D, 0.0D, 0.0D, 16.0D, 2.0D, 16.0D),   // 年龄 0
            Block.box(0.0D, 0.0D, 0.0D, 16.0D, 4.0D, 16.0D),   // 年龄 1
            Block.box(0.0D, 0.0D, 0.0D, 16.0D, 6.0D, 16.0D),   // 年龄 2
            Block.box(0.0D, 0.0D, 0.0D, 16.0D, 8.0D, 16.0D),   // 年龄 3
            Block.box(0.0D, 0.0D, 0.0D, 16.0D, 10.0D, 16.0D),  // 年龄 4
            Block.box(0.0D, 0.0D, 0.0D, 16.0D, 12.0D, 16.0D),  // 年龄 5
            Block.box(0.0D, 0.0D, 0.0D, 16.0D, 14.0D, 16.0D),  // 年龄 6
            Block.box(0.0D, 0.0D, 0.0D, 16.0D, 16.0D, 16.0D),  // 年龄 7（茎秆成熟）
            Block.box(0.0D, 0.0D, 0.0D, 16.0D, 16.0D, 16.0D)   // 年龄 8（顶部果实）
    };

    // ============================== 构造方法 ============================== //

    /**
     * 构造函数 - DeepSeek 注释
     *
     * @param properties 方块属性
     */
    public SorghumCropBlock(Properties properties) {
        super(properties);
    }

    // ============================== 方块行为 ============================== //

    /**
     * 获取碰撞体积 - DeepSeek 注释
     *
     * @return 根据当前年龄返回对应的碰撞体积
     */
    @Override
    public VoxelShape getShape(BlockState state, BlockGetter world, BlockPos pos, CollisionContext context) {
        return SHAPE_BY_AGE[this.getAge(state)];
    }

    /**
     * 随机刻更新 - DeepSeek 注释
     *
     * <p>处理作物的自然生长逻辑：</p>
     * <ul>
     *   <li>检查光照条件是否充足</li>
     *   <li>根据生长速度计算生长概率</li>
     *   <li>特殊处理第一阶段到第二阶段的过渡</li>
     *   <li><b>修复关键</b>：新增上方作物检查防止无限堆叠</li>
     * </ul>
     */
    @Override
    public void randomTick(BlockState state, ServerLevel level, BlockPos pos, RandomSource random) {
        // 检查区块是否加载
        if (!level.isAreaLoaded(pos, 1)) return;

        // 需要充足的光照（亮度 >= 9）
        if (level.getRawBrightness(pos, 0) >= 9) {
            int currentAge = this.getAge(state);

            // 如果作物未完全成熟
            if (currentAge < this.getMaxAge()) {
                // 计算当前生长速度
                float growthSpeed = getGrowthSpeed(this, level, pos);

                // 根据生长速度计算生长概率
                if (net.minecraftforge.common.ForgeHooks.onCropsGrowPre(level, pos, state,
                        random.nextInt((int)(25.0F / growthSpeed) + 1) == 0)) {

                    // 特殊处理：当达到第一阶段成熟时
                    if (currentAge == FIRST_STAGE_MAX_AGE) {
                        BlockPos abovePos = pos.above();

                        // 检查上方是否有空间且没有高粱作物
                        if (level.getBlockState(abovePos).is(Blocks.AIR) &&
                                !isSorghumCropAbove(level, abovePos)) {

                            // 在上方生成第二阶段作物
                            level.setBlock(abovePos, this.getStateForAge(currentAge + 1), 2);
                        }
                    } else {
                        // 正常生长：增加当前方块的年龄
                        level.setBlock(pos, this.getStateForAge(currentAge + 1), 2);
                    }

                    // 触发作物生长后事件
                    net.minecraftforge.common.ForgeHooks.onCropsGrowPost(level, pos, state);
                }
            }
        }
    }

    // ============================== 生存条件 ============================== //

    /**
     * 检查是否能生存 - DeepSeek 注释 (关键修复)
     *
     * <p>重构逻辑以防止无限堆叠：</p>
     * <ul>
     *   <li><b>新种植</b>：年龄0的作物必须直接位于耕地/草径上</li>
     *   <li><b>已生长</b>：年龄>0的作物可以位于耕地或成熟茎秆上</li>
     *   <li><b>严格限制</b>：禁止在顶部作物（年龄8）上方种植新作物</li>
     * </ul>
     */
    @Override
    public boolean canSurvive(BlockState state, LevelReader world, BlockPos pos) {
        int currentAge = this.getAge(state);
        BlockPos belowPos = pos.below();
        BlockState belowState = world.getBlockState(belowPos);

        // 新种植的作物（年龄0）必须直接在耕地/草径上
        if (currentAge == 0) {
            return super.canSurvive(state, world, pos); // 仅允许在耕地/草径上
        }
        // 已生长的作物可以位于耕地或成熟茎秆上
        else {
            return super.canSurvive(state, world, pos) ||
                    (belowState.is(this) && belowState.getValue(AGE) == FIRST_STAGE_MAX_AGE);
        }
    }

    /**
     * 检查上方是否有高粱作物 - DeepSeek 注释 (关键修复)
     *
     * <p>防止在高粱作物上方生成新作物</p>
     *
     * @param world 世界引用
     * @param pos 要检查的位置
     * @return 如果上方已有高粱作物则返回true
     */
    private boolean isSorghumCropAbove(LevelReader world, BlockPos pos) {
        BlockPos abovePos = pos.above();
        BlockState aboveState = world.getBlockState(abovePos);
        return aboveState.getBlock() instanceof SorghumCropBlock;
    }

    /**
     * 检查是否能支撑植物 - DeepSeek 注释
     *
     * <p>重写以允许作物在成熟茎秆上生长</p>
     */
    @Override
    public boolean canSustainPlant(BlockState state, BlockGetter world, BlockPos pos, Direction facing, IPlantable plantable) {
        return super.mayPlaceOn(state, world, pos);
    }

    // ============================== 骨粉加速 ============================== //

    /**
     * 骨粉加速生长 - DeepSeek 注释
     *
     * <p>处理骨粉使用时的特殊生长逻辑：</p>
     * <ul>
     *   <li>当作物处于第一阶段成熟时，在上方生成顶部作物</li>
     *   <li>其他阶段正常增加年龄</li>
     *   <li><b>修复关键</b>：新增上方作物检查防止骨粉创建堆叠</li>
     * </ul>
     */
    @Override
    public void growCrops(Level level, BlockPos pos, BlockState state) {
        int currentAge = this.getAge(state);
        int nextAge = currentAge + this.getBonemealAgeIncrease(level); // 骨粉增加量
        int maxAge = this.getMaxAge();

        // 确保不超过最大年龄
        if (nextAge > maxAge) {
            nextAge = maxAge;
        }

        // 特殊处理：当处于第一阶段成熟时
        if (currentAge == FIRST_STAGE_MAX_AGE) {
            BlockPos abovePos = pos.above();

            // 检查上方是否有空间且没有高粱作物
            if (level.getBlockState(abovePos).is(Blocks.AIR) &&
                    !isSorghumCropAbove(level, abovePos)) {

                // 在上方生成顶部作物（年龄8）
                level.setBlock(abovePos, this.getStateForAge(nextAge), 2);
            }
        } else {
            // 正常情况：增加当前方块的年龄
            // 注意：当nextAge超过7时，只增加到7（第一阶段成熟）
            int newAge = Math.min(nextAge, FIRST_STAGE_MAX_AGE);
            level.setBlock(pos, this.getStateForAge(newAge), 2);
        }
    }

    // ============================== 属性方法 ============================== //

    /**
     * 获取最大年龄 - DeepSeek 注释
     *
     * @return 8（0-7为茎秆，8为顶部果实）
     */
    @Override
    public int getMaxAge() {
        return FIRST_STAGE_MAX_AGE + SECOND_STAGE_MAX_AGE; // 7 + 1 = 8
    }

    /**
     * 获取基础种子 - DeepSeek 注释
     *
     * @return 高粱种子物品
     */
    @Override
    protected ItemLike getBaseSeedId() {
        return ItemLoader.SORGHUM_SEEDS.get();
    }

    /**
     * 获取年龄属性 - DeepSeek 注释
     *
     * @return AGE 属性（0-8）
     */
    @Override
    public IntegerProperty getAgeProperty() {
        return AGE;
    }

    /**
     * 创建方块状态定义 - DeepSeek 注释
     *
     * <p>注册年龄属性到方块状态</p>
     */
    @Override
    protected void createBlockStateDefinition(StateDefinition.Builder<Block, BlockState> builder) {
        builder.add(AGE);
    }
}